package server

import (
	"context"
	"fmt"

	"github.com/wzh200x/hyperNexus/hyperNexusProtocol/cacheServerProtocol"
	"github.com/wzh200x/hyperNexus/hyperNexusProtocol/commonProtocol"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/emptypb"
)

// dbAgnetServerOperateImp servant implementation
type dbAgnetServerOperateImp struct {
}

// Init servant init
func (imp *dbAgnetServerOperateImp) Init() error {
	//initialize servant here:
	//...
	return nil
}

// Destroy servant destroy
func (imp *dbAgnetServerOperateImp) Destroy() {
	//destroy servant here:
	//...
}

func (imp *dbAgnetServerOperateImp) QueryAccount(ctx context.Context,
	input commonProtocol.AccountQuery) (output commonProtocol.Account, err error) {
	// 生成缓存键
	cacheKey := "account:" + input.AccountName

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryAccount(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateAccount(ctx context.Context,
	input commonProtocol.Account) (output commonProtocol.Account, err error) {
	// 生成缓存键
	cacheKey := "account:" + input.AccountName

	// 1. 先从gdbServer查询账户是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	accountQuery := commonProtocol.AccountQuery{
		AccountName: input.AccountName,
	}
	_, err = gdbClient.QueryAccount(accountQuery)
	if err == nil {
		// 账户已存在，返回错误
		return output, fmt.Errorf("账户已存在")
	}

	// 2. 创建账户
	output, err = gdbClient.CreateAccount(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateAccount(ctx context.Context,
	input commonProtocol.Account) (output commonProtocol.Account, err error) {
	// 生成缓存键
	cacheKey := "account:" + input.AccountName

	// 1. 先从gdbServer查询账户是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	accountQuery := commonProtocol.AccountQuery{
		AccountName: input.AccountName,
	}
	_, err = gdbClient.QueryAccount(accountQuery)
	if err != nil {
		// 账户不存在，返回错误
		return output, fmt.Errorf("账户不存在")
	}

	// 2. 更新账户
	output, err = gdbClient.UpdateAccount(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreatAvatar(ctx context.Context,
	input commonProtocol.AvatarCreate) (output commonProtocol.Avatar, err error) {
	// 1. 先从gdbServer查询账户是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()

	// 2. 创建角色
	output, err = gdbClient.CreatAvatar(input)
	if err != nil {
		return output, err
	}
	// 生成缓存键
	cacheKey := "avatar:" + input.AccountName + ":" + fmt.Sprint(output.ID) + ":" + fmt.Sprint(output.HyperNexusAvatarId)
	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryAvatar(ctx context.Context,
	input commonProtocol.AvatarQuery) (output commonProtocol.Avatar, err error) {
	// 生成缓存键
	cacheKey := "avatar:" + input.AccountName + ":" + fmt.Sprint(input.AvatarId) + ":" + fmt.Sprint(input.HyperNexusAvatarId)

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryAvatar(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateAvatar(ctx context.Context,
	input commonProtocol.AvatarUpdate) (output commonProtocol.Avatar, err error) {
	// 生成缓存键
	cacheKey := "avatar:" + input.AccountName + ":" + fmt.Sprint(input.Avatar.ID) + ":" + fmt.Sprint(input.Avatar.HyperNexusAvatarId)

	// 1. 先从gdbServer查询角色是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	avatarQuery := commonProtocol.AvatarQuery{
		AccountName: input.AccountName,
	}
	if input.Avatar != nil && input.Avatar.ID > 0 {
		avatarQuery.AvatarId = input.Avatar.ID
	} else if input.Avatar != nil && input.Avatar.HyperNexusAvatarId > 0 {
		avatarQuery.HyperNexusAvatarId = input.Avatar.HyperNexusAvatarId
	}
	_, err = gdbClient.QueryAvatar(avatarQuery)
	if err != nil {
		// 角色不存在，返回错误
		return output, fmt.Errorf("角色不存在")
	}

	// 2. 更新角色
	output, err = gdbClient.UpdateAvatar(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreatAvatarModule(ctx context.Context, input commonProtocol.AvatarModuleCreate) (output commonProtocol.AvatarModule, err error) {
	// 生成缓存键
	cacheKey := "avatarmodule:" + input.AccountName + ":" + fmt.Sprint(input.AvatarId) + ":" + fmt.Sprint(input.HyperNexusAvatarId) + ":" + fmt.Sprint(input.ModuleId)

	// 1. 先从gdbServer查询模块是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	avatarModuleQuery := commonProtocol.AvatarModuleQuery{
		AccountName:        input.AccountName,
		AvatarId:           input.AvatarId,
		HyperNexusAvatarId: input.HyperNexusAvatarId,
		ModuleId:           input.ModuleId,
	}
	_, err = gdbClient.QueryAvatarModule(avatarModuleQuery)
	if err == nil {
		// 模块已存在，返回错误
		return output, fmt.Errorf("角色模块已存在")
	}

	// 2. 创建角色模块
	output, err = gdbClient.CreatAvatarModule(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryAvatarModule(ctx context.Context, input commonProtocol.AvatarModuleQuery) (output commonProtocol.AvatarModule, err error) {
	// 生成缓存键
	cacheKey := "avatarmodule:" + input.AccountName + ":" + fmt.Sprint(input.AvatarId) + ":" + fmt.Sprint(input.HyperNexusAvatarId) + ":" + fmt.Sprint(input.ModuleId)

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryAvatarModule(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateAvatarModule(ctx context.Context, input commonProtocol.AvatarModuleUpdate) (output commonProtocol.AvatarModule, err error) {
	// 生成缓存键
	cacheKey := "avatarmodule:" + input.AccountName + ":" + fmt.Sprint(input.AvatarId) + ":" + fmt.Sprint(input.HyperNexusAvatarId) + ":" + fmt.Sprint(input.ModuleId)

	// 1. 先从gdbServer查询模块是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	avatarModuleQuery := commonProtocol.AvatarModuleQuery{
		AccountName:        input.AccountName,
		AvatarId:           input.AvatarId,
		HyperNexusAvatarId: input.HyperNexusAvatarId,
		ModuleId:           input.ModuleId,
	}
	_, err = gdbClient.QueryAvatarModule(avatarModuleQuery)
	if err != nil {
		// 模块不存在，返回错误
		return output, fmt.Errorf("角色模块不存在")
	}

	// 2. 更新角色模块
	output, err = gdbClient.UpdateAvatarModule(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryCdKey(ctx context.Context,
	input commonProtocol.CdKeyQuery) (output commonProtocol.CdKey, err error) {
	// 生成缓存键
	cacheKey := "cdkey:" + input.Code

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryCdKey(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateCdKey(ctx context.Context,
	input commonProtocol.CdKey) (output commonProtocol.CdKey, err error) {
	// 生成缓存键
	cacheKey := "cdkey:" + input.Code

	// 1. 先从gdbServer查询CDKey是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyQuery := commonProtocol.CdKeyQuery{
		Code: input.Code,
	}
	_, err = gdbClient.QueryCdKey(cdKeyQuery)
	if err == nil {
		// CDKey已存在，返回错误
		return output, fmt.Errorf("CDKey已存在")
	}

	// 2. 创建CDKey
	output, err = gdbClient.CreateCdKey(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateCdKey(ctx context.Context,
	input commonProtocol.CdKey) (output commonProtocol.CdKey, err error) {
	// 生成缓存键
	cacheKey := "cdkey:" + input.Code

	// 1. 先从gdbServer查询CDKey是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyQuery := commonProtocol.CdKeyQuery{
		Code: input.Code,
	}
	_, err = gdbClient.QueryCdKey(cdKeyQuery)
	if err != nil {
		// CDKey不存在，返回错误
		return output, fmt.Errorf("CDKey不存在")
	}

	// 2. 更新CDKey
	output, err = gdbClient.UpdateCdKey(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryCdKeyGroup(ctx context.Context,
	input commonProtocol.CdKeyGroupQuery) (output commonProtocol.CdKeyGroup, err error) {
	// 生成缓存键
	cacheKey := "cdkeygroup:" + fmt.Sprint(input.ID)

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryCdKeyGroup(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateCdKeyGroup(ctx context.Context,
	input commonProtocol.CdKeyGroup) (output commonProtocol.CdKeyGroup, err error) {
	// 生成缓存键
	cacheKey := "cdkeygroup:" + fmt.Sprint(input.ID)

	// 1. 先从gdbServer查询CDKey组是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyGroupQuery := commonProtocol.CdKeyGroupQuery{
		ID: input.ID,
	}
	_, err = gdbClient.QueryCdKeyGroup(cdKeyGroupQuery)
	if err == nil {
		// CDKey组已存在，返回错误
		return output, fmt.Errorf("CDKey组已存在")
	}

	// 2. 创建CDKey组
	output, err = gdbClient.CreateCdKeyGroup(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}
func (imp *dbAgnetServerOperateImp) QueryPlatform(ctx context.Context, input commonProtocol.PlatformQuery) (output commonProtocol.PlatformQueryResponse, err error) {
	// 生成缓存键
	cacheKey := "platform:"
	// 保存没有在缓存中查询到的Key
	notFoundKeys := []string{}
	for _, key := range input.PlatformKeys {
		cacheKey += ":" + key
		// 1. 先从缓存服务器查询
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheReq := cacheServerProtocol.CacheGetRequest{
			Key: cacheKey,
		}
		cacheResp, err := cacheClient.Get(cacheReq)
		// 缓存命中
		if err == nil && len(cacheResp.Value) > 0 {
			output.Platforms = append(output.Platforms, &commonProtocol.Platform{
				PlatformKey:   key,
				PlatformValue: string(cacheResp.Value),
			})
		} else {
			notFoundKeys = append(notFoundKeys, key)
		}
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	platformQuery := commonProtocol.PlatformQuery{
		PlatformKeys: notFoundKeys,
	}
	output, err = gdbClient.QueryPlatform(platformQuery)
	if err != nil {
		return output, err
	}
	// 3. 将查询结果缓存到cacheServer，设置30D过期
	for _, platform := range output.Platforms {
		cacheKey := "platform:" + platform.PlatformKey
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      []byte(platform.PlatformValue),
			Expiration: 30 * 24 * 60 * 60, // 设置30D过期（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreatePlatform(ctx context.Context, input commonProtocol.Platform) (output commonProtocol.Platform, err error) {
	// 生成缓存键
	cacheKey := "platform:" + input.PlatformKey

	// 1. 先从gdbServer查询平台是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	platformQuery := commonProtocol.PlatformQuery{
		PlatformKeys: []string{input.PlatformKey},
	}
	queryResult, err := gdbClient.QueryPlatform(platformQuery)
	if err == nil && len(queryResult.Platforms) > 0 {
		// 平台已存在，返回错误
		return output, fmt.Errorf("平台已存在")
	}

	// 2. 创建平台
	output, err = gdbClient.CreatePlatform(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置30D过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 30 * 24 * 60 * 60, // 30天过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdatePlatform(ctx context.Context, input commonProtocol.Platform) (output commonProtocol.Platform, err error) {
	// 生成缓存键
	cacheKey := "platform:" + input.PlatformKey

	// 1. 先从gdbServer查询平台是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	platformQuery := commonProtocol.PlatformQuery{
		PlatformKeys: []string{input.PlatformKey},
	}
	_, err = gdbClient.QueryPlatform(platformQuery)
	if err != nil {
		// 平台不存在，返回错误
		return output, fmt.Errorf("平台不存在")
	}

	// 2. 更新平台
	output, err = gdbClient.UpdatePlatform(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置30D过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 30 * 24 * 60 * 60, // 30天过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateCdKeyGroup(ctx context.Context,
	input commonProtocol.CdKeyGroup) (output commonProtocol.CdKeyGroup, err error) {
	// 生成缓存键
	cacheKey := "cdkeygroup:" + fmt.Sprint(input.ID)

	// 1. 先从gdbServer查询CDKey组是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyGroupQuery := commonProtocol.CdKeyGroupQuery{
		ID: input.ID,
	}
	_, err = gdbClient.QueryCdKeyGroup(cdKeyGroupQuery)
	if err != nil {
		// CDKey组不存在，返回错误
		return output, fmt.Errorf("CDKey组不存在")
	}

	// 2. 更新CDKey组
	output, err = gdbClient.UpdateCdKeyGroup(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryCdKeyUse(ctx context.Context,
	input commonProtocol.CdKeyUseQuery) (output commonProtocol.CdKeyUseQueryResponse, err error) {
	// 生成缓存键
	cacheKey := "cdkeyuse:" + input.AccountName + ":" + fmt.Sprint(input.AvatarId) +
		":" + fmt.Sprint(input.HyperNexusAvatarId)
	if len(input.Codes) > 0 {
		for _, code := range input.Codes {
			cacheKey += ":" + code
		}
	}
	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryCdKeyUse(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateCdKeyUse(ctx context.Context,
	input commonProtocol.CdKeyUseCreateOrUpdate) (output commonProtocol.CdKeyUse, err error) {
	// 检查必要参数
	if input.CdKeyUse == nil {
		return output, fmt.Errorf("CdKeyUse不能为空")
	}

	// 生成缓存键
	cacheKey := "cdkeyuse:" + input.AccountName + ":" + fmt.Sprint(input.CdKeyUse.AvatarId) +
		":" + fmt.Sprint(input.CdKeyUse.HyperNexusAvatarId)
	if len(input.CdKeyUse.Codes) > 0 {
		for _, code := range input.CdKeyUse.Codes {
			cacheKey += ":" + code
		}
	}
	// 1. 先从gdbServer查询记录是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyUseQuery := commonProtocol.CdKeyUseQuery{
		AccountName:        input.AccountName,
		AvatarId:           input.CdKeyUse.AvatarId,
		HyperNexusAvatarId: input.CdKeyUse.HyperNexusAvatarId,
		Codes:              input.CdKeyUse.Codes,
	}
	queryResp, err := gdbClient.QueryCdKeyUse(cdKeyUseQuery)
	if err == nil && queryResp.UseData != nil && len(queryResp.UseData) > 0 {
		// 记录已存在，返回错误
		return output, fmt.Errorf("CDKey使用记录已存在")
	}

	// 2. 创建CDKey使用记录
	output, err = gdbClient.CreateCdKeyUse(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateCdKeyUse(ctx context.Context,
	input commonProtocol.CdKeyUseCreateOrUpdate) (output commonProtocol.CdKeyUse, err error) {
	// 检查必要参数
	if input.CdKeyUse == nil {
		return output, fmt.Errorf("CdKeyUse不能为空")
	}

	// 生成缓存键
	cacheKey := "cdkeyuse:" + input.AccountName + ":" + fmt.Sprint(input.CdKeyUse.AvatarId) +
		":" + fmt.Sprint(input.CdKeyUse.HyperNexusAvatarId)

	// 1. 先从gdbServer查询记录是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	cdKeyUseQuery := commonProtocol.CdKeyUseQuery{
		AccountName:        input.AccountName,
		AvatarId:           input.CdKeyUse.AvatarId,
		HyperNexusAvatarId: input.CdKeyUse.HyperNexusAvatarId,
		// Codes:              input.CdKeyUse.Codes,
	}
	queryResp, err := gdbClient.QueryCdKeyUse(cdKeyUseQuery)
	if err != nil || queryResp.UseData == nil || len(queryResp.UseData) == 0 {
		// 记录不存在，返回错误
		return output, fmt.Errorf("CDKey使用记录不存在")
	}

	// 2. 更新CDKey使用记录
	output, err = gdbClient.UpdateCdKeyUse(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryCenter(ctx context.Context,
	input commonProtocol.CenterQuery) (output commonProtocol.Center, err error) {
	// 生成缓存键
	cacheKey := "center:" + input.Account

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryCenter(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateCenter(ctx context.Context,
	input commonProtocol.Center) (output commonProtocol.Center, err error) {
	// 生成缓存键
	cacheKey := "center:" + input.Account

	// 1. 先从gdbServer查询Center是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	centerQuery := commonProtocol.CenterQuery{
		Account: input.Account,
	}
	_, err = gdbClient.QueryCenter(centerQuery)
	if err == nil {
		// Center已存在，返回错误
		return output, fmt.Errorf("Center已存在")
	}

	// 2. 创建Center
	output, err = gdbClient.CreateCenter(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateCenter(ctx context.Context,
	input commonProtocol.Center) (output commonProtocol.Center, err error) {
	// 生成缓存键
	cacheKey := "center:" + input.Account

	// 1. 先从gdbServer查询Center是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	centerQuery := commonProtocol.CenterQuery{
		Account: input.Account,
	}
	_, err = gdbClient.QueryCenter(centerQuery)
	if err != nil {
		// Center不存在，返回错误
		return output, fmt.Errorf("Center不存在")
	}

	// 2. 更新Center
	output, err = gdbClient.UpdateCenter(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryGameConfig(ctx context.Context,
	input emptypb.Empty) (output commonProtocol.GameConfigQueryResponse, err error) {
	// 生成缓存键
	cacheKey := "gameconfig:all"

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryGameConfig(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateGameConfig(ctx context.Context,
	input commonProtocol.GameConfig) (output commonProtocol.GameConfig, err error) {
	// 1. 先从gdbServer查询配置是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	// 查询所有配置
	emptyInput := emptypb.Empty{}
	configs, err := gdbClient.QueryGameConfig(emptyInput)
	if err == nil {
		// 检查是否已存在相同ID的配置
		for _, config := range configs.Configs {
			if config.ID == input.ID {
				// 配置已存在，返回错误
				return output, fmt.Errorf("游戏配置已存在")
			}
		}
	}

	// 2. 创建游戏配置
	output, err = gdbClient.CreateGameConfig(input)
	if err != nil {
		return output, err
	}

	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	// 同时清除全部配置的缓存，因为新增了配置
	cacheDeleteReq := cacheServerProtocol.CacheDeleteRequest{
		Key: "gameconfig:all",
	}
	_, _ = cacheClient.Delete(cacheDeleteReq)

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateGameConfig(ctx context.Context,
	input commonProtocol.GameConfig) (output commonProtocol.GameConfig, err error) {
	// 1. 先从gdbServer查询配置是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	// 查询所有配置
	emptyInput := emptypb.Empty{}
	configs, err := gdbClient.QueryGameConfig(emptyInput)
	if err != nil {
		return output, err
	}

	// 检查是否存在要更新的配置
	configExists := false
	for _, config := range configs.Configs {
		if config.ID == input.ID {
			configExists = true
			break
		}
	}

	if !configExists {
		// 配置不存在，返回错误
		return output, fmt.Errorf("游戏配置不存在")
	}

	// 2. 更新游戏配置
	output, err = gdbClient.UpdateGameConfig(input)
	if err != nil {
		return output, err
	}
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	// 同时清除全部配置的缓存，因为更新了配置
	cacheDeleteReq := cacheServerProtocol.CacheDeleteRequest{
		Key: "gameconfig:all",
	}
	_, _ = cacheClient.Delete(cacheDeleteReq)
	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryOrder(ctx context.Context,
	input commonProtocol.OrderQuery) (output commonProtocol.OrderQueryResponse, err error) {
	// 生成缓存键
	cacheKey := "order:" + input.AccountName + ":" + input.Order

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryOrder(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateOrder(ctx context.Context,
	input commonProtocol.Order) (output commonProtocol.Order, err error) {
	// 生成缓存键
	cacheKey := "order:" + input.Account + ":" + input.Order

	// 1. 先从gdbServer查询订单是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	orderQuery := commonProtocol.OrderQuery{
		AccountName:        input.Account,
		HyperNexusAvatarId: input.HyperNexusAvatarId,
		Order:              input.Order,
	}
	queryRet, err := gdbClient.QueryOrder(orderQuery)
	if err == nil && len(queryRet.Orders) > 0 {
		// 订单已存在，返回错误
		return output, fmt.Errorf("订单已存在")
	}

	// 2. 创建订单
	output, err = gdbClient.CreateOrder(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateOrder(ctx context.Context,
	input commonProtocol.Order) (output commonProtocol.Order, err error) {
	// 生成缓存键
	cacheKey := "order:" + input.Account + ":" + input.Order
	// 1. 先从gdbServer查询订单是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	orderQuery := commonProtocol.OrderQuery{
		AccountName: input.Account,
	}
	if input.HyperNexusAvatarId > 0 {
		orderQuery.HyperNexusAvatarId = input.HyperNexusAvatarId
	}
	if input.Order != "" {
		orderQuery.Order = input.Order
	}
	_, err = gdbClient.QueryOrder(orderQuery)
	if err != nil {
		// 订单不存在，返回错误
		return output, fmt.Errorf("订单不存在")
	}
	// 2. 更新订单
	output, err = gdbClient.UpdateOrder(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QueryServer(ctx context.Context,
	input commonProtocol.ServerQuery) (output commonProtocol.ServerQueryResponse, err error) {
	// 生成缓存键
	cacheKey := "servers"
	if input.Zone > 0 {
		cacheKey = fmt.Sprintf("servers:%d", input.Zone)
	}

	// 1. 先从缓存服务器查询
	cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
	cacheReq := cacheServerProtocol.CacheGetRequest{
		Key: cacheKey,
	}
	cacheResp, err := cacheClient.Get(cacheReq)

	// 缓存命中，直接返回
	if err == nil && len(cacheResp.Value) > 0 {
		// 反序列化缓存数据
		if err = proto.Unmarshal(cacheResp.Value, &output); err == nil {
			return output, nil
		}
		// 反序列化失败，继续从数据库查询
	}

	// 2. 缓存未命中，从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QueryServer(input)
	if err != nil {
		return output, err
	}

	// 3. 将查询结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateServer(ctx context.Context,
	input commonProtocol.Server) (output commonProtocol.Server, err error) {
	// 生成缓存键
	cacheKey := "servers"
	if input.Zone > 0 {
		cacheKey = fmt.Sprintf("servers:%d", input.Zone)
	} else {
		return output, fmt.Errorf("必须指定服务器ID")
	}

	// 1. 先从gdbServer查询服务器是否已存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	serverQuery := commonProtocol.ServerQuery{
		Zone: input.Zone,
	}
	queryResp, err := gdbClient.QueryServer(serverQuery)
	if err == nil && queryResp.Servers != nil && len(queryResp.Servers) > 0 {
		// 服务器已存在，返回错误
		return output, fmt.Errorf("服务器已存在")
	}

	// 2. 创建服务器
	output, err = gdbClient.CreateServer(input)
	if err != nil {
		return output, err
	}

	// 3. 将创建结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)

		// 同时更新服务器列表缓存
		// 清除服务器列表缓存，让下次查询时重新加载
		cacheDelReq := cacheServerProtocol.CacheDeleteRequest{
			Key: "servers",
		}
		_, _ = cacheClient.Delete(cacheDelReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateServer(ctx context.Context,
	input commonProtocol.Server) (output commonProtocol.Server, err error) {
	if input.ID <= 0 {
		return output, fmt.Errorf("必须指定更新ID")
	}
	// 生成缓存键
	cacheKey := fmt.Sprintf("servers:%d", input.Zone)

	// 1. 先从gdbServer查询服务器是否存在
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	serverQuery := commonProtocol.ServerQuery{
		Zone: input.Zone,
	}
	queryResp, err := gdbClient.QueryServer(serverQuery)
	if err != nil || queryResp.Servers == nil || len(queryResp.Servers) == 0 {
		// 服务器不存在，返回错误
		return output, fmt.Errorf("服务器不存在")
	}

	// 2. 更新服务器
	output, err = gdbClient.UpdateServer(input)
	if err != nil {
		return output, err
	}

	// 3. 将更新结果缓存到cacheServer，设置24小时过期
	data, err := proto.Marshal(&output)
	if err == nil {
		cacheClient := ServerApp.CacheServerProxy.GetClientProxy()
		cacheSetReq := cacheServerProtocol.CacheSetRequest{
			Key:        cacheKey,
			Value:      data,
			Expiration: 24 * 60 * 60, // 24小时过期时间（秒）
		}
		// 异步缓存，不关心结果
		_, _ = cacheClient.Set(cacheSetReq)

		// 同时更新服务器列表缓存
		// 清除服务器列表缓存，让下次查询时重新加载
		cacheDelReq := cacheServerProtocol.CacheDeleteRequest{
			Key: "servers",
		}
		_, _ = cacheClient.Delete(cacheDelReq)
	}

	return output, nil
}

func (imp *dbAgnetServerOperateImp) QuerySubscribe(ctx context.Context,
	input commonProtocol.SubscribeQuery) (output commonProtocol.SubscribeQueryResponse, err error) {
	// 从gdbServer查询
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	output, err = gdbClient.QuerySubscribe(input)
	if err != nil {
		return output, err
	}
	return output, nil
}

func (imp *dbAgnetServerOperateImp) CreateSubscribe(ctx context.Context,
	input commonProtocol.Subscribe) (output commonProtocol.Subscribe, err error) {
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	// 2. 创建订阅
	output, err = gdbClient.CreateSubscribe(input)
	if err != nil {
		return output, err
	}
	return output, nil
}

func (imp *dbAgnetServerOperateImp) UpdateSubscribe(ctx context.Context,
	input commonProtocol.Subscribe) (output commonProtocol.Subscribe, err error) {
	gdbClient := ServerApp.GdbServerProxy.GetClientProxy()
	// 2. 更新订阅
	output, err = gdbClient.UpdateSubscribe(input)
	if err != nil {
		return output, err
	}
	return output, nil
}
